/**
 * 配送模块API服务
 * 基于JH项目的API结构，使用明道云低代码开发平台接口
 * 参考JH项目的axios实现，解决移动端加载问题
 * 支持从 mdye.env.config 读取运行时参数，实现参数化配置
 */

import axios from 'axios'
import { 
  API_CONFIG, 
  WORKSHEET_IDS, 
  VIEW_IDS, 
  DELIVERY_ORDER_FIELDS,
  DELIVERY_SITE_FIELDS,
  DRIVER_FIELDS,
  VEHICLE_FIELDS,
  CONTAINER_FIELDS,
  PAGINATION_CONFIG,
  WEBHOOKS,
  getFieldValue,
  getFieldValueSmart,
  transformDeliveryOrderData,
  transformDeliverySiteData,
  transformDriverData,
  transformVehicleData,
  transformContainerData,
  validateConfig,
  getConfigSnapshot
} from '../config/delivery-config.js'

// 确保在浏览器环境中正常工作的axios配置
if (typeof window !== 'undefined') {
  axios.defaults.adapter = 'xhr'
}

// 内联简单的工具函数，避免复杂依赖
const safeJSONStringify = (obj) => {
  try {
    return JSON.stringify(obj)
  } catch (error) {
    console.warn('JSON stringify failed:', error)
    return '""'
  }
}

const safeJSONParse = (str) => {
  try {
    return JSON.parse(str)
  } catch (error) {
    console.warn('JSON parse failed:', error)
    return null
  }
}

const handleNetworkError = (error) => {
  if (!error) return '未知网络错误'
  
  if (error.code === 'NETWORK_ERROR' || error.message?.includes('Network')) {
    return '网络连接失败，请检查网络设置'
  }
  
  if (error.code === 'TIMEOUT_ERROR' || error.message?.includes('timeout')) {
    return '请求超时，请重试'
  }
  
  if (error.response?.status === 404) {
    return '请求的资源不存在'
  }
  
  if (error.response?.status === 500) {
    return '服务器内部错误'
  }
  
  return error.message || '请求失败'
}

// 基于JH项目的axios配置 - 使用动态配置
const BASE_CONFIG = {
  timeout: 15000 // 增加超时时间到15秒，确保创建请求不会超时
}

const http = axios.create(BASE_CONFIG)

// 参考JH项目的请求拦截器 - 支持动态配置
http.interceptors.request.use(
  config => {
    // 动态设置baseURL
    config.baseURL = API_CONFIG.baseURL
    config.headers['Content-Type'] = 'application/json'
    return config
  },
  error => {
    console.error('请求拦截器错误:', error)
    return Promise.reject(error)
  }
)

// 参考JH项目的响应拦截器
http.interceptors.response.use(
  response => {
    const { data } = response
    
    // 检查明道云API的响应格式
    if (data && typeof data === 'object') {
      // 明道云API错误码检查：error_code = 1 表示成功，其他值表示错误
      if (data.error_code !== undefined) {
        if (data.error_code !== 1) {
          const errorMsg = data.error_msg || data.msg || `明道云API错误，错误码: ${data.error_code}`
          console.warn('明道云API错误:', errorMsg)
          // 不抛出错误，返回空数据结构
          return { rows: [], data: { rows: [] }, success: false, message: errorMsg }
        }
        return data
      }
      
      // 如果有success字段，检查它
      if (data.hasOwnProperty('success')) {
        if (!data.success) {
          console.warn('API请求失败:', data.message || data.msg || '请求失败')
          return { rows: [], data: { rows: [] }, success: false, message: data.message || data.msg }
        }
        return data
      }
      
      // 没有明确的错误标识，假设请求成功
      return data
    }
    
    return response.data
  },
  error => {
    const errorMessage = handleNetworkError(error)
    console.warn('配送API响应错误:', errorMessage)
    
    // 不抛出错误，返回一个安全的响应结构
    return {
      rows: [],
      data: { rows: [] },
      success: false,
      message: errorMessage,
      error: true
    }
  }
)

// 配送模块配置已移至 delivery-config.js，支持从 mdye.env.config 读取

/**
 * 配送API服务类 - 支持从 mdye.env.config 读取配置
 */
class DeliveryApiService {
  constructor() {
    if (DeliveryApiService.instance) {
      return DeliveryApiService.instance;
    }
    
    // 使用getter延迟读取配置，支持运行时参数化
    Object.defineProperties(this, {
      appKey: {
        get() { return API_CONFIG.appKey; }
      },
      sign: {
        get() { return API_CONFIG.sign; }
      },
      secretKey: {
        get() { return API_CONFIG.secretKey; }
      },
      baseURL: {
        get() { return API_CONFIG.baseURL; }
      }
    });
    
    DeliveryApiService.instance = this;
  }

  /**
   * 基础API请求方法 - 支持配置检查和调试
   */
  async makeRequest(endpoint, params = {}) {
    try {
      // 首次调用时打印配置信息
      if (!this._configLogged) {
        console.log('[mdye.env.config keys]:', Object.keys(window.mdye?.env?.config || {}));
        console.log('[config snapshot]:', getConfigSnapshot());
        this._configLogged = true;
      }
      
      // 检查必要参数
      const requiredParams = ['appKey', 'sign'];
      const missingParams = requiredParams.filter(param => !this[param]);
      if (missingParams.length > 0) {
        console.warn('缺少必要参数:', missingParams);
        return { rows: [], success: false, message: `缺少必要参数: ${missingParams.join(', ')}` };
      }
      
      const requestData = {
        appKey: this.appKey,
        sign: this.sign,
        notGetTotal: false,
        pageSize: 50,
        pageIndex: 1,
        ...params
      };

      // 处理filters参数
      if (requestData.filters && Array.isArray(requestData.filters)) {
        if (requestData.filters.length > 0) {
          requestData.filters = JSON.stringify(requestData.filters);
        } else {
          delete requestData.filters;
        }
      }

      console.log(`发起API请求: ${endpoint}`, requestData);
      
      // 使用axios发送请求（参考JH项目实现）
      const result = await http.post(endpoint, requestData);
      
      // 检查响应是否包含错误信息
      if (result && result.error) {
        console.warn(`API请求返回错误: ${endpoint}`, result);
        return { rows: [], data: { rows: [] }, success: false, message: result.message || '请求失败' };
      }
      
      return result;
    } catch (error) {
      console.error(`配送API请求失败 ${endpoint}:`, error);
      
      // 返回安全的默认结构而不是抛出错误
      return { 
        rows: [], 
        data: { rows: [] }, 
        success: false, 
        message: error.message || '网络请求失败' 
      };
    }
  }

  /**
   * 获取配送单列表
   */
  async getDeliveryOrders() {
    try {
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.DELIVERY_ORDERS,
        filters: []
      });
      
      // 处理响应数据
      let actualRows = null;
      if (response.rows) {
        actualRows = response.rows;
      } else if (response.data && response.data.rows) {
        actualRows = response.data.rows;
      } else if (response.data && Array.isArray(response.data)) {
        actualRows = response.data;
      }
      
      if (actualRows && Array.isArray(actualRows)) {
        // 转换数据格式
        const transformedData = this.transformDeliveryOrderData(actualRows);
        return transformedData;
      }
      
      console.warn('未找到有效的配送单数据');
      return [];
    } catch (error) {
      console.error('获取配送单数据失败:', error);
      throw error;
    }
  }

  /**
   * 发送配送单创建webhook（简化版本）
   */
  async createDeliveryOrder(deliveryData) {
    try {
      console.log('=== 开始配送单webhook发送流程 ===');
      console.log('配送单数据:', deliveryData);
      
      // 1. 提取容器码
      let containerCodes = [];
      if (deliveryData.containers && Array.isArray(deliveryData.containers) && deliveryData.containers.length > 0) {
        containerCodes = deliveryData.containers.map(container => {
          let code = '';
          if (typeof container === 'object') {
            if (container.rawData) {
              code = container.rawData['686b42983f0e1b398c1cac71'] || 
                     container.rawData.containerCode || '';
            }
            code = code || container.containerCode || container.code || container.id || container.rowid;
          } else {
            code = String(container);
          }
          return code;
        }).filter(code => code);
      }
      
      // 2. 构建Webhook载荷
      const webhookPayload = {
        deliveryMethod: deliveryData.method || deliveryData.deliveryMethod || '',
        destination: deliveryData.destination || '',
        driverId: deliveryData.driver || '',
        vehicleId: deliveryData.vehicle || '',
        containerCodes: containerCodes,
        containerCount: containerCodes.length,
        remarks: deliveryData.remarks || '',
        createdAt: new Date().toISOString(),
        timestamp: Date.now()
      };
      
      console.log('=== 准备发送创建Webhook ===');
      console.log('Webhook载荷:', webhookPayload);
      
      // 3. 获取Webhook地址（从明道云插件参数中读取）
      console.log('=== 调试配置读取过程 ===');
      console.log('window.mdye存在:', !!window.mdye);
      console.log('window.mdye.env存在:', !!window.mdye?.env);
      console.log('window.mdye.env.config存在:', !!window.mdye?.env?.config);
      console.log('完整config对象:', window.mdye?.env?.config);
      
      const config = window.mdye?.env?.config || {};
      console.log('可用配置键:', Object.keys(config));
      console.log('CREATE_WEBHOOK_URL原始值:', config.CREATE_WEBHOOK_URL);
      console.log('webhookUrl原始值:', config.webhookUrl);
      console.log('createWebhookUrl原始值:', config.createWebhookUrl);
      
      // 使用配置系统读取webhook地址
      const webhookUrlFromConfig = WEBHOOKS.CREATE;
      console.log('通过WEBHOOKS.CREATE获取:', webhookUrlFromConfig);
      
      // 备用方案：直接从config读取
      const webhookUrlDirect = config.CREATE_WEBHOOK_URL || 
                               config.webhookUrl || 
                               config.createWebhookUrl;
      console.log('直接从config获取:', webhookUrlDirect);
      
      const webhookUrl = webhookUrlFromConfig || webhookUrlDirect;
      console.log('最终获取的Webhook URL:', webhookUrl);
      
      if (!webhookUrl) {
        console.error('❌ 未配置webhook地址');
        console.log('📋 请在明道云插件中添加以下任一参数:');
        console.log('   - CREATE_WEBHOOK_URL: 配送单创建专用webhook地址');
        console.log('   - webhookUrl: 通用webhook地址');
        console.log('   - createWebhookUrl: 创建webhook地址');
        
        return {
          success: false,
          message: '未配置webhook地址，请在明道云插件中添加 CREATE_WEBHOOK_URL 或 webhookUrl 参数'
        };
      }
      
      // 4. 发送Webhook请求
      try {
        const webhookResponse = await fetch(webhookUrl, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify(webhookPayload)
        });
        
        console.log('=== Webhook响应 ===');
        console.log('响应状态:', webhookResponse.status);
        console.log('响应状态文本:', webhookResponse.statusText);
        
        let responseData = null;
        try {
          responseData = await webhookResponse.text();
          console.log('响应内容:', responseData);
          
          if (responseData) {
            try {
              responseData = JSON.parse(responseData);
            } catch (e) {
              // 保持原始文本
            }
          }
        } catch (e) {
          console.log('无响应内容或解析失败');
        }
        
        if (!webhookResponse.ok) {
          console.warn('⚠️ Webhook发送失败');
          return {
            success: false,
            message: `Webhook发送失败: ${webhookResponse.status} ${webhookResponse.statusText}`,
            webhookError: `${webhookResponse.status} ${webhookResponse.statusText}`,
            webhookUrl: webhookUrl
          };
        }
        
        console.log('✅ Webhook发送成功');
        return {
          success: true,
          message: '配送单webhook发送成功',
          webhookResponse: responseData,
          webhookUrl: webhookUrl,
          timestamp: new Date().toISOString()
        };
        
      } catch (webhookError) {
        console.error('❌ Webhook发送异常:', webhookError);
        return {
          success: false,
          message: `Webhook发送异常: ${webhookError.message}`,
          webhookError: webhookError.message,
          webhookUrl: webhookUrl
        };
      }
      
    } catch (error) {
      console.error('❌ 配送单webhook发送流程失败:', error);
      return {
        success: false,
        message: `Webhook发送流程失败: ${error.message}`,
        error: error.message
      };
    }
  }

  /**
   * 更新配送单状态
   */
  async updateDeliveryStatus(orderId, status) {
    try {
      if (!DELIVERY_ORDER_FIELDS.STATUS) {
        return { success: true }; // 暂时返回成功
      }
      
      const response = await this.makeRequest('editRow', {
        worksheetId: WORKSHEET_IDS.DELIVERY_ORDERS,
        rowId: orderId,
        controls: [
          {
            controlId: DELIVERY_ORDER_FIELDS.STATUS,
            value: status
          }
        ]
      });
      
      return { success: true };
    } catch (error) {
      console.error('更新配送单状态失败:', error);
      throw error;
    }
  }

  /**
   * 获取配送站点列表
   */
  async getDeliverySites() {
    try {
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.DELIVERY_SITES,
        filters: []
      });
      
      // 处理响应数据
      let actualRows = null;
      if (response.rows) {
        actualRows = response.rows;
      } else if (response.data && response.data.rows) {
        actualRows = response.data.rows;
      } else if (response.data && Array.isArray(response.data)) {
        actualRows = response.data;
      }
      
      if (actualRows && Array.isArray(actualRows)) {
        // 转换数据格式 - 使用正确的配送站点信息字段
        const transformedData = actualRows.map(row => ({
          id: row.rowid || '',
          name: row[DELIVERY_SITE_FIELDS.NAME] || '未知站点',
          siteInfo: row[DELIVERY_SITE_FIELDS.SITE_INFO] || '',
          rawData: row
        }));
        console.log('=== 配送站点数据转换完成 ===');
        console.log('配送站点信息字段ID:', DELIVERY_SITE_FIELDS.SITE_INFO);
        console.log('站点数据样例:', transformedData.slice(0, 2));
        console.log('第一个站点的siteInfo字段:', transformedData[0]?.siteInfo);
        return transformedData;
      }
      
      console.warn('未找到有效的配送站点数据');
      return [];
    } catch (error) {
      console.error('获取配送站点数据失败:', error);
      throw error;
    }
  }

  /**
   * 获取司机列表
   */
  async getDrivers() {
    try {
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.DRIVERS,
        filters: []
      });
      
      // 处理响应数据
      let actualRows = null;
      if (response.rows) {
        actualRows = response.rows;
      } else if (response.data && response.data.rows) {
        actualRows = response.data.rows;
      } else if (response.data && Array.isArray(response.data)) {
        actualRows = response.data;
      }
      
      if (actualRows && Array.isArray(actualRows)) {
        // 转换数据格式 - 使用正确的司机管理表字段ID
        const transformedData = actualRows.map(row => ({
          id: row.rowid || '',
          name: row[DRIVER_FIELDS.NAME] || '未知司机',
          contact: row[DRIVER_FIELDS.CONTACT] || '',
          displayText: `${row[DRIVER_FIELDS.NAME] || '未知司机'} (${row[DRIVER_FIELDS.CONTACT] || '无联系方式'})`,
          rawData: row
        }));
        console.log('司机数据转换完成，样例:', transformedData.slice(0, 2));
        return transformedData;
      }
      
      console.warn('未找到有效的司机数据');
      return [];
    } catch (error) {
      console.error('获取司机数据失败:', error);
      throw error;
    }
  }

  /**
   * 获取车辆列表
   */
  async getVehicles() {
    try {
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.VEHICLES,
        filters: []
      });
      
      // 处理响应数据
      let actualRows = null;
      if (response.rows) {
        actualRows = response.rows;
      } else if (response.data && response.data.rows) {
        actualRows = response.data.rows;
      } else if (response.data && Array.isArray(response.data)) {
        actualRows = response.data;
      }
      
      if (actualRows && Array.isArray(actualRows)) {
        // 转换数据格式 - 使用正确的车辆管理表字段ID
        const transformedData = actualRows.map(row => ({
          id: row.rowid || '',
          plateNumber: row[VEHICLE_FIELDS.PLATE_NUMBER] || '',
          model: row[VEHICLE_FIELDS.MODEL] || '',
          // 优先显示车牌号，如果没有车牌号则显示车型
          displayText: row[VEHICLE_FIELDS.PLATE_NUMBER] || row[VEHICLE_FIELDS.MODEL] || '未知车辆',
          rawData: row
        }));
        console.log('车辆数据转换完成，样例:', transformedData.slice(0, 2));
        return transformedData;
      }
      
      console.warn('未找到有效的车辆数据');
      return [];
    } catch (error) {
      console.error('获取车辆数据失败:', error);
      throw error;
    }
  }

  /**
   * 获取容器列表
   */
  async getContainers() {
    try {
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.CONTAINERS,
        filters: []
      });
      
      // 处理响应数据
      let actualRows = null;
      if (response.rows) {
        actualRows = response.rows;
      } else if (response.data && response.data.rows) {
        actualRows = response.data.rows;
      } else if (response.data && Array.isArray(response.data)) {
        actualRows = response.data;
      }
      
      if (actualRows && Array.isArray(actualRows)) {
        // 转换数据格式
        const transformedData = actualRows.map(row => ({
          id: row.rowid || '',
          products: row[CONTAINER_FIELDS.PRODUCTS] || '',
          rawData: row
        }));
        return transformedData;
      }
      
      console.warn('未找到有效的容器数据');
      return [];
    } catch (error) {
      console.error('获取容器数据失败:', error);
      throw error;
    }
  }

  /**
   * 获取容器管理表数据（用于筛选）
   */
  async getContainersByWorksheet() {
    try {
      console.log('=== 开始获取容器管理表数据 ===');
      console.log('工作表ID:', WORKSHEET_IDS.CONTAINER_MANAGEMENT);
      
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.CONTAINER_MANAGEMENT,
        filters: []
      });
      
      // 处理响应数据
      let actualRows = null;
      if (response.rows) {
        actualRows = response.rows;
      } else if (response.data && response.data.rows) {
        actualRows = response.data.rows;
      } else if (response.data && Array.isArray(response.data)) {
        actualRows = response.data;
      }
      
      if (actualRows && Array.isArray(actualRows)) {
        console.log('原始数据行数:', actualRows.length);
        if (actualRows.length > 0) {
          console.log('第一行数据的字段:', Object.keys(actualRows[0]));
          console.log('状态字段ID:', CONTAINER_FIELDS.STATUS);
          console.log('第一行状态字段值:', actualRows[0][CONTAINER_FIELDS.STATUS]);
        }
        
        // 转换数据格式 - 确保状态字段被正确处理
        const transformedData = actualRows.map((row, index) => {
          const transformed = {
            id: row.rowid || '',
            products: row[CONTAINER_FIELDS.PRODUCTS] || '',
            containerCode: row[CONTAINER_FIELDS.CONTAINER_CODE] || '',
            siteInfo: row[CONTAINER_FIELDS.CONTAINER_SITE_INFO] || '',
            // 显式提取状态字段 - 使用配置的字段ID
            status: row[CONTAINER_FIELDS.STATUS] || '',
            rawData: row
          };
          
          // 调试前3行数据
          if (index < 3) {
            console.log(`转换后的数据${index + 1}:`, {
              id: transformed.id,
              status: transformed.status,
              hasRawData: !!transformed.rawData
            });
          }
          
          return transformed;
        });
        
        console.log('=== 容器管理表数据获取完成 ===');
        return transformedData;
      }
      
      console.warn('未找到有效的容器管理数据');
      return [];
    } catch (error) {
      console.error('获取容器管理数据失败:', error);
      throw error;
    }
  }

  /**
   * 获取容器关联详情
   */
  async getContainerRelationDetails(containerId) {
    try {
      const response = await fetch('https://www.dachen.vip/api/v2/open/worksheet/getRowRelations', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          worksheetId: WORKSHEET_IDS.CONTAINER_MANAGEMENT,
          rowId: containerId,
          relationFieldId: CONTAINER_FIELDS.RELATION_FIELD
        })
      });
      
      if (!response.ok) {
        throw new Error(`API请求失败: ${response.status}`);
      }
      
      const data = await response.json();
      return data;
    } catch (error) {
      console.error('获取容器关联详情失败:', error);
      throw error;
    }
  }

  /**
   * 配送单数据转换函数
   */
  transformDeliveryOrderData(rows) {
    if (!rows || !Array.isArray(rows)) {
      console.warn('transformDeliveryOrderData: rows is not an array:', typeof rows, rows);
      return [];
    }
    
    
    return rows.map((row, index) => {
      // 获取配送单号（从配送单号字段）
      const orderNumber = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.ORDER_NUMBER) || row.rowid || '';
      
      // 获取拥有容器字段（用于显示容器码）
      const ownedContainersValue = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.CONTAINER_CODES) || '';
      
      // 获取配送方式（从配送方式字段）
      const deliveryMethod = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.METHOD) || '未知配送方式';
      
      // 获取发运目的地（从发运目的地字段）
      const destination = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.DESTINATION) || '未设置';
      
      // 获取司机姓名（使用专用方法处理关联字段）
      const driverName = this.getDriverDisplayName(row, DELIVERY_ORDER_FIELDS.DRIVER);
      
      // 获取手机号（从手机号字段）
      const phoneNumber = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.PHONE_NUMBER) || '';
      
      // 获取车牌号（使用专用方法处理关联字段）
      const vehicleInfo = this.getVehicleDisplayName(row, DELIVERY_ORDER_FIELDS.VEHICLE);
      
      // 获取状态（从状态字段）
      const status = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.STATUS) || 'pending';
      
      // 获取容器数量（从容器数量字段）
      const containerCount = parseInt(this.getFieldValue(row, DELIVERY_ORDER_FIELDS.CONTAINER_COUNT) || '0') || 0;
      
      // 获取存放商品数（从存放商品数字段）
      const storedProductCount = parseInt(this.getFieldValue(row, DELIVERY_ORDER_FIELDS.STORED_PRODUCT_COUNT) || '0') || 0;
      
      // 获取备注
      const remarks = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.REMARKS) || '';
      
      // 获取创建时间
      const createdAt = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.CREATED_AT) || new Date().toISOString();
      
      // 获取汇总字段的体积和重量（使用专用方法处理可能的关联字段格式）
      const volume = this.getVolumeValue(row, DELIVERY_ORDER_FIELDS.VOLUME);
      const weight = this.getWeightValue(row, DELIVERY_ORDER_FIELDS.WEIGHT);
      
      // 从拥有容器字段获取容器码
      const containerCodes = ownedContainersValue ? ownedContainersValue.split(',').map(code => code.trim()).filter(code => code) : [];
      
      const result = {
        id: row.rowid || '',
        orderNumber: orderNumber,                    // 配送单号字段值
        deliveryMethod: deliveryMethod,              // 配送方式字段值
        destination: destination,                    // 发运目的地字段值
        driverName: driverName,                      // 司机字段值
        phoneNumber: phoneNumber,                    // 手机号字段值
        vehicleInfo: vehicleInfo,                    // 车牌号字段值
        driver: driverName,                          // 保持兼容性
        vehicle: vehicleInfo,                        // 保持兼容性
        remarks: remarks,
        status: status,                              // 状态字段值
        createdAt: createdAt,
        // 汇总字段数据
        volume: volume,
        weight: weight,
        containerCodes: containerCodes,
        containerCount: containerCount,              // 容器数量字段值
        storedProductCount: storedProductCount,      // 存放商品数字段值
        // 格式化显示
        volumeDisplay: volume > 0 ? `${volume.toFixed(2)}m³` : '0m³',
        weightDisplay: weight > 0 ? `${weight.toFixed(2)}kg` : '0kg',
        productCountDisplay: `${containerCount}种商品`,
        storedProductCountDisplay: `${storedProductCount}个`,
        rawData: row
      };
      
      // 调试拥有容器字段
      if (process.env.NODE_ENV === 'development') {
        console.log(`配送单 ${row.rowid}: 拥有容器字段(${DELIVERY_ORDER_FIELDS.CONTAINER_CODES})="${ownedContainersValue}", 容器码数组=[${containerCodes.join(',')}]`);
      }
      
      // 详细调试司机字段
      console.log('=== 司机字段调试 ===');
      console.log('司机字段原始数据:', row[DELIVERY_ORDER_FIELDS.DRIVER]);
      console.log('司机字段类型:', typeof row[DELIVERY_ORDER_FIELDS.DRIVER]);
      console.log('司机字段最终值:', driverName);
      
      // 详细调试车辆字段  
      console.log('=== 车辆字段调试 ===');
      console.log('车辆字段原始数据:', row[DELIVERY_ORDER_FIELDS.VEHICLE]);
      console.log('车辆字段类型:', typeof row[DELIVERY_ORDER_FIELDS.VEHICLE]);
      console.log('车辆字段最终值:', vehicleInfo);
      
      // 详细调试体积字段
      console.log('=== 体积字段调试 ===');
      console.log('体积字段原始数据:', row[DELIVERY_ORDER_FIELDS.VOLUME]);
      console.log('体积字段类型:', typeof row[DELIVERY_ORDER_FIELDS.VOLUME]);
      console.log('体积字段最终值:', volume);
      
      // 详细调试重量字段
      console.log('=== 重量字段调试 ===');
      console.log('重量字段原始数据:', row[DELIVERY_ORDER_FIELDS.WEIGHT]);
      console.log('重量字段类型:', typeof row[DELIVERY_ORDER_FIELDS.WEIGHT]);
      console.log('重量字段最终值:', weight);
      
      console.log('手机号字段值:', phoneNumber);
      console.log('状态字段值:', status);
      console.log('容器数量字段值:', containerCount);
      console.log('=============================');
      
      return result;
    }).filter(item => item !== null);
  }

  /**
   * 获取体积数值的专用方法
   */
  getVolumeValue(data, fieldId) {
    const value = this.getFieldValue(data, fieldId, '0');
    
    // 如果是关联字段数组格式
    if (Array.isArray(data[fieldId]) && data[fieldId].length > 0) {
      const volumeData = data[fieldId][0];
      if (typeof volumeData === 'object') {
        // 尝试从汇总字段中获取体积数值
        return parseFloat(volumeData.value || volumeData.sum || volumeData.total || '0') || 0;
      }
      return parseFloat(volumeData) || 0;
    }
    
    return parseFloat(value) || 0;
  }

  /**
   * 获取重量数值的专用方法
   */
  getWeightValue(data, fieldId) {
    const value = this.getFieldValue(data, fieldId, '0');
    
    // 如果是关联字段数组格式
    if (Array.isArray(data[fieldId]) && data[fieldId].length > 0) {
      const weightData = data[fieldId][0];
      if (typeof weightData === 'object') {
        // 尝试从汇总字段中获取重量数值
        return parseFloat(weightData.value || weightData.sum || weightData.total || '0') || 0;
      }
      return parseFloat(weightData) || 0;
    }
    
    return parseFloat(value) || 0;
  }

  /**
   * 获取司机显示名称的专用方法
   */
  getDriverDisplayName(data, fieldId) {
    const value = this.getFieldValue(data, fieldId, '');
    
    // 如果是关联字段数组格式
    if (Array.isArray(data[fieldId]) && data[fieldId].length > 0) {
      const driverData = data[fieldId][0];
      if (typeof driverData === 'object') {
        // 尝试从司机管理表的字段中获取司机姓名
        return driverData[DRIVER_FIELDS.NAME] || // 司机管理表中的司机姓名字段
               driverData.name || 
               driverData.title || 
               driverData.displayName ||
               '未知司机';
      }
      return String(driverData) || '未知司机';
    }
    
    return value || '未知司机';
  }

  /**
   * 获取车辆显示名称的专用方法 - 优先显示车牌号
   */
  getVehicleDisplayName(data, fieldId) {
    const value = this.getFieldValue(data, fieldId, '');
    
    // 如果是关联字段数组格式
    if (Array.isArray(data[fieldId]) && data[fieldId].length > 0) {
      const vehicleData = data[fieldId][0];
      if (typeof vehicleData === 'object') {
        // 优先从车辆管理表的字段中获取车牌号
        const plateNumber = vehicleData[VEHICLE_FIELDS.PLATE_NUMBER];
        if (plateNumber) {
          return plateNumber;
        }
        // 如果没有车牌号，再尝试获取车型或其他信息
        return vehicleData[VEHICLE_FIELDS.MODEL] || 
               vehicleData.name || 
               vehicleData.title || 
               vehicleData.displayName ||
               '未知车辆';
      }
      return String(vehicleData) || '未知车辆';
    }
    
    return value || '未知车辆';
  }

  /**
   * 从明道云数据中获取字段值的工具函数
   */
  getFieldValue(data, fieldId, defaultValue = '') {
    if (!data || !fieldId) {
      return defaultValue;
    }
    
    // 明道云数据格式：数据直接作为对象属性
    if (typeof data === 'object' && !Array.isArray(data)) {
      const value = data[fieldId];
      
      // 处理关联字段 - 明道云关联字段通常返回数组格式
      if (Array.isArray(value) && value.length > 0) {
        const firstItem = value[0];
        // 尝试获取关联记录的显示名称
        if (typeof firstItem === 'object') {
          // 常见的显示字段名称
          return firstItem.name || firstItem.title || firstItem.displayName || 
                 firstItem[DRIVER_FIELDS.NAME] || // 司机姓名字段
                 firstItem[VEHICLE_FIELDS.PLATE_NUMBER] || // 车牌号字段
                 firstItem.value || 
                 JSON.stringify(firstItem);
        } else {
          return String(firstItem);
        }
      }
      
      // 处理普通字段值
      return value !== undefined && value !== null ? String(value) : defaultValue;
    }
    
    return defaultValue;
  }

  /**
   * 配置验证方法
   */
  validateConfiguration() {
    const issues = [];
    
    if (!this.appKey) issues.push('缺少AppKey');
    if (!this.sign) issues.push('缺少Sign');
    if (!WORKSHEET_IDS.DELIVERY_ORDERS) issues.push('缺少配送单工作表ID');
    if (!WORKSHEET_IDS.DELIVERY_SITES) issues.push('缺少配送站点工作表ID');
    if (!WORKSHEET_IDS.CONTAINERS) issues.push('缺少容器工作表ID');
    if (!DELIVERY_ORDER_FIELDS.METHOD) issues.push('缺少配送方式字段ID');
    
    
    return {
      isValid: issues.length === 0,
      issues
    };
  }

  /**
   * 获取已被其他配送单使用的容器码列表
   * @param {string} excludeOrderId - 要排除的配送单ID（当前正在编辑的配送单）
   * @returns {Promise<Array>} 已被使用的容器码数组
   */
  async getUsedContainerCodes(excludeOrderId = '') {
    try {
      console.log('=== 获取已被使用的容器码列表 ===');
      console.log('排除的配送单ID:', excludeOrderId);
      
      // 获取所有配送单数据
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.DELIVERY_ORDERS,
        filters: []
      });
      
      let actualRows = null;
      if (response.rows) {
        actualRows = response.rows;
      } else if (response.data && response.data.rows) {
        actualRows = response.data.rows;
      } else if (response.data && Array.isArray(response.data)) {
        actualRows = response.data;
      }
      
      if (!actualRows || !Array.isArray(actualRows)) {
        console.warn('未获取到有效的配送单数据');
        return [];
      }
      
      console.log(`获取到 ${actualRows.length} 条配送单记录`);
      
      // 提取所有配送单的容器码，排除指定的配送单ID
      const usedContainerCodes = new Set();
      
      actualRows.forEach((row, index) => {
        const orderId = row.rowid;
        
        // 如果指定了要排除的配送单ID，跳过该配送单
        if (excludeOrderId && orderId === excludeOrderId) {
          console.log(`跳过当前编辑的配送单: ${orderId}`);
          return;
        }
        
        // 获取该配送单的容器码
        const containerCodesField = this.getFieldValue(row, DELIVERY_ORDER_FIELDS.CONTAINER_CODES, '');
        
        if (containerCodesField && containerCodesField.trim()) {
          // 容器码用逗号分隔
          const codes = containerCodesField.split(',').map(code => code.trim()).filter(code => code);
          codes.forEach(code => {
            usedContainerCodes.add(code);
            if (index < 3) { // 只调试前3条记录
              console.log(`配送单 ${orderId} 使用容器码: ${code}`);
            }
          });
        }
      });
      
      const result = Array.from(usedContainerCodes);
      console.log('=== 已被使用的容器码汇总 ===');
      console.log(`总计 ${result.length} 个容器码被其他配送单使用:`);
      console.log(result.slice(0, 10)); // 只显示前10个
      if (result.length > 10) {
        console.log(`... 还有 ${result.length - 10} 个容器码`);
      }
      
      return result;
      
    } catch (error) {
      console.error('获取已使用容器码失败:', error);
      return [];
    }
  }

  /**
   * 测试webhook配置
   */
  testWebhookConfig() {
    console.log('=== Webhook配置测试 ===');
    console.log('window.mdye:', !!window.mdye);
    console.log('window.mdye.env:', !!window.mdye?.env);
    console.log('window.mdye.env.config:', !!window.mdye?.env?.config);
    
    const config = window.mdye?.env?.config || {};
    console.log('所有配置键:', Object.keys(config));
    console.log('CREATE_WEBHOOK_URL:', config.CREATE_WEBHOOK_URL);
    
    const webhookUrl = WEBHOOKS.CREATE;
    console.log('WEBHOOKS.CREATE结果:', webhookUrl);
    
    return {
      configExists: !!window.mdye?.env?.config,
      configKeys: Object.keys(config),
      createWebhookUrl: config.CREATE_WEBHOOK_URL,
      webhooksCreateResult: webhookUrl
    };
  }

  /**
   * 测试基础连接的方法
   */
  async testConnection() {
    try {
      const response = await this.makeRequest('getFilterRows', {
        worksheetId: WORKSHEET_IDS.DELIVERY_ORDERS,
        pageSize: 1  // 只获取1条记录用于测试
      });
      return {
        success: true,
        data: response
      };
    } catch (error) {
      console.error('配送模块连接测试失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }
}

// 创建单例实例
const deliveryApi = new DeliveryApiService();

export default deliveryApi;